package com.example.langchain4j.service;

import cn.hutool.json.JSONUtil;
import com.deepoove.poi.XWPFTemplate;
import com.example.langchain4j.assistant.AssistantAgent;
import com.example.langchain4j.common.exception.BusinessException;
import com.example.langchain4j.utils.DocumentUtils;
import com.example.langchain4j.utils.TemplateUtils;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.chat.request.ChatRequest;
import dev.langchain4j.model.chat.response.ChatResponse;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Map;

@Slf4j
@Service
public class ChatService {

    @Autowired
    private ChatLanguageModel chatLanguageModel;

    @Resource
    private AssistantAgent assistant;

    public String chat(String message) {
        ChatResponse chat = chatLanguageModel.chat(ChatRequest.builder().messages(UserMessage.from(message)).build());
        String result = chat.aiMessage().text();
        System.out.println("User: " + message);
        System.out.println("AI: " + result);
        return result;
    }

    public void generationShenpibiao(MultipartFile file1, MultipartFile file2, HttpServletResponse response) {
        OutputStream out = null;
        BufferedOutputStream bos = null;
        try {
            // 提取文档内容
            String document1Content = DocumentUtils.extractTextFromWord(file1);
            String document2Content = DocumentUtils.extractTextFromWord(file2);

            // 加载resource下面的json模板
            String jsonTemplate = TemplateUtils.loadCaseApprovalTemplate("立案审批表示例.txt");

//            String message = String.format("文档1内容：\n%s\n\n" +
//                    "文档2内容：\n%s\n\n" ,document1Content, document2Content);
//            String message = buildComparisonPrompt(document1Content, document2Content, jsonTemplate);
            // 第一次调用：生成结构化JSON数据
            String jsonResult = assistant.chat(document1Content,document2Content,jsonTemplate);

            // 清理JSON字符串，移除可能的markdown标记和推理过程
            jsonResult = cleanJsonString(jsonResult);

            Map<String, Object> resultMap = JSONUtil.toBean(jsonResult, Map.class);
            System.out.println(resultMap);

            // 从resources目录加载审批表.docx模板
            ClassPathResource resource = new ClassPathResource("行政处罚立案审批表template.docx");
            InputStream templateInputStream = resource.getInputStream();
            XWPFTemplate template = XWPFTemplate.compile(templateInputStream).render(resultMap);


            response.setContentType("application/octet-stream");
            response.setHeader("Content-disposition","attachment;filename=\""+"out_template.docx"+"\"");
            out = response.getOutputStream();
            bos = new BufferedOutputStream(out);
            template.write(bos);
            bos.flush();
            out.flush();
        } catch (IOException e) {
            throw new BusinessException(500, "生成文档失败！" + e.getMessage());
        } finally {
            try {
                if (out != null) {
                    out.close();
                }
                if (bos != null) {
                    bos.close();
                }
            } catch (IOException e) {
               log.error("关闭流异常！", e);
            }
        }
    }

    private String buildComparisonPrompt(String document1, String document2, String jsonTemplate) {
        return String.format(
                "你是一个专业的文档分析助手。请分析以下两个文档内容，并根据提供的JSON模板生成结构化数据。\n\n" +
                        "文档1内容：\n%s\n\n" +
                        "文档2内容：\n%s\n\n" +
                        "请根据以上两个文档的内容，按照以下JSON模板生成结构化数据：\n%s\n\n" +
                        "要求：\n" +
                        "1. 仔细阅读并理解两个文档的内容\n" +
                        "2. 提取两个文档中的关键信息并进行对比分析\n" +
                        "3. 根据JSON模板的结构组织提取的信息\n" +
                        "4. 对于模板中需要但文档中未提及的字段，请留空或空串\n" +
                        "5. 确保生成的JSON格式正确且符合模板要求\n" +
                        "6. 只返回最终的JSON数据，不要包含任何解释性文字或其他内容\n\n" +
                        "请生成符合模板的JSON数据：",
                document1, document2, jsonTemplate);
    }

    /**
     * 清理JSON字符串，移除markdown代码块标记和额外说明
     * 特别处理推理模型（如qwq）的思考过程输出
     */
    private String cleanJsonString(String jsonString) {
        if (jsonString == null || jsonString.trim().isEmpty()) {
            return jsonString;
        }

        String cleaned = jsonString.trim();

        // 移除开头的markdown标记
        if (cleaned.startsWith("```json")) {
            cleaned = cleaned.substring(7);
        } else if (cleaned.startsWith("```")) {
            cleaned = cleaned.substring(3);
        }

        // 移除结尾的markdown标记
        if (cleaned.endsWith("```")) {
            cleaned = cleaned.substring(0, cleaned.length() - 3);
        }

        cleaned = cleaned.trim();

        // 特殊处理：如果内容包含思考过程（常见于推理模型），尝试提取JSON部分
        // 查找最后一个完整的JSON对象（从最后一个 } 往前找到对应的 {）
        int lastBrace = cleaned.lastIndexOf('}');
        if (lastBrace != -1) {
            // 从lastBrace往前找匹配的 {
            int braceCount = 1;
            int firstBrace = lastBrace - 1;
            while (firstBrace >= 0 && braceCount > 0) {
                if (cleaned.charAt(firstBrace) == '}') {
                    braceCount++;
                } else if (cleaned.charAt(firstBrace) == '{') {
                    braceCount--;
                }
                firstBrace--;
            }
            firstBrace++; // 调整到 { 的位置

            if (firstBrace >= 0 && braceCount == 0) {
                // 找到了完整的JSON对象
                String potentialJson = cleaned.substring(firstBrace, lastBrace + 1);
                // 验证是否像JSON（简单检查：包含引号和冒号）
                if (potentialJson.contains("\"") && potentialJson.contains(":")) {
                    cleaned = potentialJson;
                    log.info("从推理模型输出中提取到JSON，长度: {}", cleaned.length());
                }
            }
        }

        // 如果上面没有找到，使用原来的逻辑：查找第一个 { 和最后一个 }
        if (!cleaned.startsWith("{")) {
            int firstBrace = cleaned.indexOf('{');
            int lastBraceSimple = cleaned.lastIndexOf('}');

            if (firstBrace != -1 && lastBraceSimple != -1 && firstBrace < lastBraceSimple) {
                // 提取 {} 之间的内容
                cleaned = cleaned.substring(firstBrace, lastBraceSimple + 1);
            }
        }

        return cleaned.trim();
    }
}